#include <iostream>
#include <vector>
#include <queue>
#include <chrono>
#include <thread>
#include <mutex>              // 补充头文件
#include <condition_variable> // 补充头文件
#include <functional>         // 补充头文件

template<typename T>
class BlockingQueuePro {
public:
    // 构造函数，初始化 nonblock_ 为 false
    BlockingQueuePro(bool nonblock = false) : nonblock_(nonblock) {}
    
    // 向队列中添加元素
    void Push(const T& value) {
        std::unique_lock<std::mutex> lock(producer_mutex_);
        producer_queue_.push(value);
        // 如果队列不为空，则通知一个等待的消费者线程
        std::cout<<"push a new task"<<std::endl;
        not_empty_.notify_one();
    }

    // 从队列中取出元素
    bool Pop(T& value) {
        std::unique_lock<std::mutex> lock(consumer_mutex_);
        // 如果队列为空且交换队列数量为0，则直接返回 false
        if (consumer_queue_.empty() && SwapQueue_() == 0) {
            return false;
        }
        // 取出队列中的元素
        value = std::move(consumer_queue_.front()); // 使用 move 提高效率
        consumer_queue_.pop();
        return true;
    }

    // 取消阻塞
    void Cancel() {
        std::unique_lock<std::mutex> lock(producer_mutex_); // 修正中文分号为英文
        nonblock_ = true;
        // 通知所有等待的消费者线程
        not_empty_.notify_all();
    }

private:
    // 交换队列
    int SwapQueue_() {
        std::unique_lock<std::mutex> lock(producer_mutex_);
        // 修正 lambda 表达式括号闭合问题
        //如果队列为空则等待，直到队列不为空或者非阻塞
        not_empty_.wait(lock, [this] { return !producer_queue_.empty() || nonblock_; });
        std::swap(producer_queue_, consumer_queue_); // 修正 st::swap 为 std::swap
        return consumer_queue_.size();
    }

    // 是否阻塞
    bool nonblock_;
    // 生产者队列
    std::queue<T> producer_queue_;
    // 消费者队列
    std::queue<T> consumer_queue_;
    std::mutex producer_mutex_;
    std::mutex consumer_mutex_;
    std::condition_variable not_empty_;
};

class Threadpool {
public:
    explicit Threadpool(int num_thread) {
        for (int i = 0; i < num_thread; ++i) { // 修正 size_t 为 int
            workers_.emplace_back([this] { Worker(); }); // 移除多余的 -> void
        }
    }

    ~Threadpool() {
        task_queue_.Cancel();
        for (auto& worker : workers_) {
            if (worker.joinable()) {
                worker.join();
            }
        }
    }

    template<typename F, typename... Args>
    void Post(F&& f, Args&&... args) {
        auto task = std::bind(std::forward<F>(f), std::forward<Args>(args)...);
        task_queue_.Push(task);
    }

private:
    void Worker() {
        while (true) {
            std::function<void()> task;
            if (!task_queue_.Pop(task)) { // Pop 返回 false 时退出循环
                break;
            }
            task(); // Pop 返回 true 时执行任务
        }
    }

    BlockingQueuePro<std::function<void()>> task_queue_;
    std::vector<std::thread> workers_; // 修正变量名拼写错误（wockers_ -> workers_）
};

// 测试代码
int main() {
    Threadpool pool(4);
    for (int i = 0; i < 100; ++i) {
        pool.Post([i] {
            std::chrono::milliseconds(1000);
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            std::cout << "Task " << i << " executed by thread "
                      << std::this_thread::get_id() << std::endl;
        });
    }
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 0;
}